home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cpp_libs / rjs.lha / RJS / Transport / src / Transport.h < prev    next >
C/C++ Source or Header  |  1991-06-14  |  9KB  |  289 lines
  1. #ifndef RJS_TRANSPORT_CLASS_H
  2. #define RJS_TRANSPORT_CLASS_H
  3.  
  4. #include <sys/socket.h>
  5. #include <sys/types.h>
  6. #include <sys/un.h>
  7. #include <netinet/in.h>
  8. #include <arpa/inet.h>
  9.  
  10. #include <netdnet/dn.h>
  11. #include <netdnet/dnetdb.h>
  12.  
  13. #include <iostream.h>
  14.  
  15. typedef struct sockaddr *SOCKADDR_PTR;
  16. typedef const struct sockaddr *CONST_SOCKADDR_PTR;
  17.  
  18. #include <RJS/Status.h>
  19.  
  20. class RJS_NetworkAddress : public virtual RJS_Status {
  21. public:
  22.     static const RJS_Status
  23.         NoHostGiven,
  24.         UnknownHost,
  25.         HostFound;
  26. };
  27.  
  28. class RJS_InetAddress : public RJS_NetworkAddress {
  29.     friend ostream &operator<<(ostream &os, const RJS_InetAddress &ia);
  30. public:
  31.     static char *Any;    // any address
  32.     static char *Broadcast;    // broadcast address
  33.     static const RJS_Status UnKnownService;
  34.     RJS_InetAddress();
  35.     RJS_InetAddress(const char *hostname,int port);
  36.     RJS_InetAddress(int port);
  37.     RJS_InetAddress(const char *hostname,const char *service,const char *proto);
  38.     RJS_InetAddress(const char *service,const char *proto);
  39.     lookup(const char *hostname,int port);
  40.     lookup(int port) {
  41.             return lookup(Any,port);
  42.     }
  43.     lookup(const char *hostname,const char *service,const char *proto);
  44.     lookup(const char *service,const char *proto) {
  45.             return lookup(Any,service,proto);
  46.     }
  47.     const char *hostname() const;
  48.     const char *numeric_hostname() const;
  49.     int size() const { return sizeof(address); }
  50.     int port() const;
  51.     int isany() const { return any_flag; }
  52.     int isbroadcast() const { return broadcast_flag; }
  53.     operator SOCKADDR_PTR() { return (SOCKADDR_PTR) &address; }
  54.     operator CONST_SOCKADDR_PTR() const { return (SOCKADDR_PTR) &address; }
  55.     struct sockaddr_in    address;
  56.     int            addrlen;
  57.     int            any_flag;
  58.     int            broadcast_flag;
  59. };
  60.  
  61. class RJS_UnixAddress : public RJS_NetworkAddress {
  62.     friend ostream &operator<<(ostream &os, const RJS_UnixAddress &ia);
  63. public:
  64.     static const RJS_Status NoPathGiven;
  65.     static char *Temp;    // any address
  66.     RJS_UnixAddress();
  67.     RJS_UnixAddress(const char *pathname);
  68.     void set(const char *pathname);
  69.     const char *pathname() const;
  70.     int size() const { return sizeof(address); }
  71.     operator SOCKADDR_PTR() { return (SOCKADDR_PTR) &address; }
  72.     operator CONST_SOCKADDR_PTR() const { return (SOCKADDR_PTR) &address; }
  73.  
  74.     struct sockaddr_un    address;
  75.     int            addrlen;
  76. };
  77.  
  78. class RJS_DECnetAddress : public RJS_NetworkAddress {
  79.     friend ostream &operator<<(ostream &os, const RJS_DECnetAddress &ia);
  80. public:
  81.     static const RJS_Status UnKnownObject;
  82.     RJS_DECnetAddress();
  83.     RJS_DECnetAddress(int object);
  84.     RJS_DECnetAddress(const char *object);
  85.     RJS_DECnetAddress(const char *node, int obj);
  86.     RJS_DECnetAddress(const char *node, const char *obj);
  87.     lookup(const char *hostname,int object);
  88.     lookup(const char *hostname,const char *object);
  89.     lookup(int object);
  90.     lookup(const char *object);
  91.     const char *hostname() const;
  92.     const char *objname() const;
  93.     int objnum() const { return address.sdn_objnum; }
  94.     int size() const { return sizeof(address); }
  95.     operator SOCKADDR_PTR() { return (SOCKADDR_PTR) &address; }
  96.     operator CONST_SOCKADDR_PTR() const { return (SOCKADDR_PTR) &address; }
  97.     void dump();
  98.     struct sockaddr_dn    address;
  99.     int            addrlen;
  100. };
  101.  
  102. class RJS_Transport : public virtual RJS_Status {
  103.   public:
  104.     RJS_Transport();
  105.     virtual void abstract_class()=0;
  106.     virtual int  close();
  107.     virtual int  read(char *buffer, int len);
  108.     virtual int  write(const char *buffer,int len);
  109.     virtual int  readv(const struct iovec *, int);
  110.     virtual int  writev(const struct iovec *, int);
  111.     virtual int  inuse();
  112.     virtual int  ok();
  113.     virtual ~RJS_Transport() {};
  114.     int          return_on_error;
  115. protected:
  116.     int            td;    // the transport file descriptor
  117. };
  118.  
  119.  
  120. class RJS_Socket : public RJS_Transport {
  121.     void abstract_class() {}
  122. public:
  123.     enum SocketSex { Unknown,Active,Passive};
  124.     enum AddressFamily {    // just work with these three for now
  125.         AfUnix    =  AF_UNIX,
  126.         AfInet    =  AF_INET,
  127.         AfDECnet  =  AF_DECnet
  128.     };
  129.     enum SocketType {
  130.         Stream    =  SOCK_STREAM,
  131.         Datagram  =  SOCK_DGRAM,
  132.         Raw       =  SOCK_RAW,
  133.         RDM       =  SOCK_RDM,
  134.         SeqPacket =  SOCK_SEQPACKET
  135.     };
  136.     enum MsgSendFlags {    
  137.         MsgSendNoFlags        =    0,
  138.         MsgSendDontRoute    =    MSG_DONTROUTE,
  139.         MsgSendOob        =    MSG_OOB,
  140.         MsgSendDontRouteOob =    MSG_OOB|MSG_DONTROUTE
  141.     };
  142.     enum MsgReceiveFlags {    
  143.         MsgReceiveNoFlags =    0,
  144.         MsgReceivePeek      =    MSG_PEEK,
  145.         MsgReceiveOob      =    MSG_OOB,
  146.         MsgReceivePeekOob =    MSG_OOB|MSG_PEEK
  147.     };
  148.     enum ShutDownType { 
  149.         ShutDownReceive=0, 
  150.         ShutDownSend=1, 
  151.         ShutDownBoth=2 
  152.     };
  153.     enum FlagOption { Off = 0, On  = 1 };
  154.     enum SocketLevelOption {
  155.         Broadcast    =    SO_BROADCAST,
  156.         Debug        =    SO_DEBUG,
  157.         DontRoute    =    SO_DONTROUTE,
  158.         KeepAlive    =    SO_KEEPALIVE,
  159.         OOBInline    =    SO_OOBINLINE,
  160.         ReuseAddr    =    SO_REUSEADDR,
  161.         UseLoopBack    =    SO_USELOOPBACK
  162.     };
  163.     RJS_Socket( AddressFamily af,SocketType st);
  164.     ~RJS_Socket();
  165.     virtual int socket();
  166.     virtual void dump();
  167.     int accept(struct sockaddr *sa, int &len);
  168.     int bind(const struct sockaddr *,int);
  169.     int connect(const struct sockaddr *,int);
  170.     int getpeername(struct sockaddr *, int &len);
  171.     int getsockname(struct sockaddr *, int &len);
  172.     int getsockopt(int, int, char *, int *);    //
  173.     int listen(int);
  174.     int recv(char *, int, MsgReceiveFlags=MsgReceiveNoFlags);
  175.     int recvfrom(char *, int, struct sockaddr *, 
  176.             int &,MsgReceiveFlags=MsgReceiveNoFlags);
  177.     int send(const char *, int,MsgSendFlags=MsgSendNoFlags);
  178.     int sendto(const char *, int, const struct sockaddr *, 
  179.             int,MsgSendFlags=MsgSendNoFlags); 
  180.     int setsockopt(int, int, const char *, int);    //
  181.     int recvmsg(struct msghdr *, MsgReceiveFlags=MsgReceiveNoFlags);
  182.     int sendmsg(struct msghdr *, MsgSendFlags=MsgSendNoFlags);
  183.     virtual void shutdown(ShutDownType);
  184.     void linger();
  185.     int setsockopt(SocketLevelOption slo, FlagOption fo);
  186.     int getsockopt(SocketLevelOption slo, FlagOption &fo);
  187.     AddressFamily address_family()         { return family;    }
  188.     SocketType    socket_type()         { return type;        }
  189.     SocketSex     socket_sex()        { return sex;        }
  190.     int          socket_protocol()        { return protocol;    }
  191.     int          is_active()        { return sex==Active;    }
  192.     int          is_passive()        { return sex==Passive;    }
  193. protected:
  194.     RJS_Socket(AddressFamily af);
  195.     RJS_Socket(SocketType st);
  196.     int          check_syscall(int stat,char *mess);
  197.     int          syscall(int stat,char *mess);
  198.     SocketType          type;    // Socket Type
  199.     AddressFamily         family;    // Address Family
  200.     int          protocol;     // Protocol (currently 0)
  201.     SocketSex           sex;    // Active or Passive
  202. };
  203.  
  204. class RJS_UnixSocket : public RJS_Socket {
  205. public:
  206.     RJS_UnixSocket(SocketType st) : RJS_Socket(RJS_Socket::AfUnix,st) {}
  207.     int passive(const RJS_UnixAddress &ua);
  208.     int active(const RJS_UnixAddress &ua);
  209.     ~RJS_UnixSocket();
  210.     int accept(RJS_UnixSocket &newsocket);
  211.     int close();
  212.     int getpeername(RJS_UnixAddress &ua);
  213.     int getsockname(RJS_UnixAddress &ua);
  214. private:
  215.     const char        *filename;
  216.     int            unlink_socket;
  217. };
  218.  
  219. class RJS_InetSocket : public RJS_Socket {
  220. public:        
  221.     RJS_InetSocket(SocketType st) : RJS_Socket(RJS_Socket::AfInet,st) {}
  222.     int accept(RJS_InetSocket &newsocket);
  223.     int bind(const RJS_InetAddress &ia);
  224.     int connect(const RJS_InetAddress &ia);
  225.     int getpeername(RJS_InetAddress &ia);
  226.     getsockname(RJS_InetAddress &ia);
  227.     int recvfrom(char *buffer,int maxbuf,RJS_InetAddress &is);
  228.     int sendto(char *buffer,int len,const RJS_InetAddress &is);
  229. };
  230.  
  231. class RJS_DECnetSocket : public RJS_Socket {
  232. public:
  233.     RJS_DECnetSocket(SocketType st) : RJS_Socket(AfDECnet,st) {};    
  234.     int accept(RJS_DECnetSocket &newsocket);
  235.     int dnet_conn(const char *node, const char *obj); // use dnet_conn
  236.     int active(const RJS_DECnetAddress &da);
  237.     int passive(const RJS_DECnetAddress &da);
  238.     int dnet_eof();
  239. };
  240.  
  241. class RJS_UnixStream : public RJS_UnixSocket {
  242. public:
  243.     RJS_UnixStream() : RJS_UnixSocket(Stream) {}
  244.     int accept(RJS_UnixStream &newstream) {
  245.         return RJS_UnixSocket::accept(newstream);
  246.     }
  247. };
  248.  
  249. class RJS_InetStream :public RJS_InetSocket {
  250. public:                        
  251.     RJS_InetStream() : RJS_InetSocket(Stream) { }
  252.      int accept(RJS_InetStream &newstream) {
  253.         return RJS_InetSocket::accept(newstream);
  254.     }
  255.     int reserved_socket(int starting_port); // create port using rresvport
  256.     int passive(const RJS_InetAddress &ia);
  257.     int active(const RJS_InetAddress &ia);
  258. };
  259.  
  260. class RJS_DECnetStream : public RJS_DECnetSocket {
  261. public:
  262.     RJS_DECnetStream() : RJS_DECnetSocket(Stream) {};    
  263.     int accept(RJS_DECnetStream &newstream) {
  264.         return RJS_DECnetSocket::accept(newstream);
  265.     }
  266. };
  267.  
  268. class RJS_DECnetSeqPacket : public RJS_DECnetSocket {
  269. public:
  270.     RJS_DECnetSeqPacket() : RJS_DECnetSocket(SeqPacket) {};
  271.     int accept(RJS_DECnetSeqPacket &newseq) {
  272.         return RJS_DECnetSocket::accept(newseq);
  273.     }
  274. };
  275.  
  276. class RJS_InetDatagram :public RJS_InetSocket {
  277. public:                        
  278.     RJS_InetDatagram() : RJS_InetSocket(Datagram) { }
  279.      int accept(RJS_InetDatagram &newsock) {
  280.         return RJS_InetSocket::accept(newsock);
  281.     }
  282.     int socket(); 
  283.     int active();
  284.     int passive(const RJS_InetAddress &ia);
  285. };
  286.  
  287. // endif TRANSPORT_CLASS_H
  288. #endif
  289.